{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "71e6d8fe-84c4-47d7-8fd7-f6a66fed72e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports \n",
    "import os\n",
    "import json\n",
    "import operator\n",
    "import pandas as pd\n",
    "from io import StringIO\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# settings\n",
    "BotHash = \"BEEB1E1549DDD01226DC2FC912ABAE49\"\n",
    "BotName = \"PokerShark2\"\n",
    "SB = 10\n",
    "\n",
    "# players\n",
    "Players = ['PokerShark1']\n",
    "\n",
    "# helper functions\n",
    "def prettyPrint(*arguments):\n",
    "    out = ''\n",
    "    for arg in arguments:\n",
    "        space = (30-len(arg)) * \" \"\n",
    "        out += arg + space\n",
    "    print(out)\n",
    "\n",
    "# gets an array of paths to player games\n",
    "def getGamesPath(playerName):\n",
    "    return [os.path.join(playerName,f) for f in os.listdir(playerName) if not f.startswith('.')]\n",
    "\n",
    "# Load game as json object.\n",
    "def loadGame(path):\n",
    "    with open(path) as f:\n",
    "        g = json.load(f)\n",
    "        # Throw if game not logged by the current version of the bot\n",
    "        if g[\"BotHash\"] != BotHash:\n",
    "            #raise Exception(\"BotHash does not match: \" + g[\"BotHash\"])\n",
    "            pass\n",
    "        return g\n",
    "\n",
    "# game statistics\n",
    "def getGamesCount(playerName):\n",
    "    # returns number of games played against the given player.\n",
    "    return len(getGamesPath(playerName))\n",
    "\n",
    "def getGameResultForPlayer(game, playerName):\n",
    "    # returns game result for given player.\n",
    "    results = game[\"Results\"]\n",
    "    maxStack = 0\n",
    "    hasMax = []\n",
    "    # find max stack\n",
    "    for result in results:\n",
    "        if maxStack < result[\"Stack\"]:\n",
    "            maxStack = result[\"Stack\"]\n",
    "            hasMax= [result[\"Player\"][\"Name\"]]\n",
    "        elif maxStack == result[\"Stack\"]:\n",
    "            hasMax.append(result[\"Player\"][\"Name\"])\n",
    "    # find player result\n",
    "    if playerName in hasMax:\n",
    "        if len(hasMax) > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "\n",
    "def getWonGamesCount(playerName):\n",
    "    # returns number of games won against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'W':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getDrewGamesCount(playerName):\n",
    "    # return number of games drew against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'D':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getLostGamesCount(playerName):\n",
    "    # return number of games lost against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'L':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getEndStack(playerName):\n",
    "    # return sum of the stack after the games.\n",
    "    s = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for result in game[\"Results\"]:\n",
    "            if result[\"Player\"][\"Name\"] == BotName:\n",
    "                s += result[\"Stack\"]\n",
    "    return s\n",
    "            \n",
    "# round statistics\n",
    "def getRoundsCount(playerName):\n",
    "    # returns number of rounds played against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        count += len(game[\"Rounds\"])\n",
    "    return count\n",
    "\n",
    "def GetRoundResultForPlayer(r, playerName):\n",
    "    results = r[\"Winner\"]\n",
    "    winners = len(results)\n",
    "    won = False\n",
    "    for result in results:\n",
    "        if playerName == result[\"Name\"]:\n",
    "            won = True\n",
    "            break\n",
    "    if won:\n",
    "        if winners > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "\n",
    "def getWonRoundsCount(playerName):\n",
    "    # returns number of rounds won against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'W':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def getDrewRoundsCount(playerName):\n",
    "    # return number of games rounds against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'D':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def getLostRoundsCount(playerName):\n",
    "    # return number of rounds lost against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'L':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def endedBeforeShowdown(r):\n",
    "    # returns true if one of the two players folded.\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] == \"Fold\":\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "def botFolded(r):\n",
    "    # returns true if one of the two players folded.\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] == \"Fold\" and action[\"PlayerName\"] == BotName:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "def getPaid(r,playerName):\n",
    "    # returns amount paid by player\n",
    "    amount = 0\n",
    "    # blinds\n",
    "    sbp = r['SmallBlindPosition']\n",
    "    for p in range(len(r['Players'])):\n",
    "        if r['Players'][p]['Name'] == playerName:\n",
    "            if p == sbp:\n",
    "                amount += SB\n",
    "            else:\n",
    "                amount += SB + SB\n",
    "    # calls and raises\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] != \"Fold\" and action[\"PlayerName\"] == playerName:\n",
    "            amount += action[\"Amount\"]\n",
    "    return amount\n",
    "\n",
    "# winning statistics\n",
    "def getNonShowdownWinningsLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if endedBeforeShowdown(r):\n",
    "                if botFolded(r):\n",
    "                    line -= getPaid(r,BotName)\n",
    "                else:\n",
    "                    line += getPaid(r,playerName)\n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def getShowdownWinningsLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if not endedBeforeShowdown(r):\n",
    "                # if bot won\n",
    "                if GetRoundResultForPlayer(r, BotName) == 'W':\n",
    "                    line += getPaid(r,playerName)\n",
    "                if GetRoundResultForPlayer(r, BotName) == 'L':\n",
    "                    line -= getPaid(r,BotName)\n",
    "                \n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def getStackLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if GetRoundResultForPlayer(r, BotName) == 'W':\n",
    "                line += getPaid(r,playerName)\n",
    "            if GetRoundResultForPlayer(r, BotName) == 'L':\n",
    "                line -= getPaid(r,BotName)\n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def plotWinnings(playerName):\n",
    "    # NonShowdownWinningsLine\n",
    "    x,y = getNonShowdownWinningsLine(playerName)\n",
    "    fig, ax = plt.subplots()\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Non-showdown winnings', c='r')\n",
    "    # ShowdownWinningsLine\n",
    "    x,y = getShowdownWinningsLine(playerName)\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Showdown winnings', c='b')\n",
    "    # Stack\n",
    "    x,y = getStackLine(playerName)\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Winnings', c='g')\n",
    "    # show plot\n",
    "    y_max = np.abs(ax.get_ylim()).max()\n",
    "    ax.set_ylim(ymin=-y_max, ymax=y_max)\n",
    "    ax.set_xlim(left=0)\n",
    "    plt.legend()\n",
    "    plt.grid(linestyle = '--', linewidth = 0.5)\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "# Print Results\n",
    "def PrintResult():\n",
    "    for player in Players:\n",
    "        prettyPrint(\"Results against:\", player)\n",
    "        # game statistics\n",
    "        n = getGamesCount(player)\n",
    "        w = getWonGamesCount(player)\n",
    "        d = getDrewGamesCount(player)\n",
    "        l = getLostGamesCount(player)\n",
    "        prettyPrint(\"number of games:\",str(n))\n",
    "        prettyPrint(\"number of games won:\", str(w) , \"{:.1f}\".format(w*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games drew:\", str(d), \"{:.1f}\".format(d*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games lost:\", str(l), \"{:.1f}\".format(l*100/n) + \"%\")\n",
    "        # round statistics\n",
    "        rn = getRoundsCount(player)\n",
    "        rw = getWonRoundsCount(player)\n",
    "        rd = getDrewRoundsCount(player)\n",
    "        rl = getLostRoundsCount(player)\n",
    "        prettyPrint(\"number of rounds:\",str(rn))\n",
    "        prettyPrint(\"number of rounds won:\", str(rw) , \"{:.1f}\".format(rw*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds drew:\", str(rd), \"{:.1f}\".format(rd*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds lost:\", str(rl), \"{:.1f}\".format(rl*100/rn) + \"%\")\n",
    "        # winnings\n",
    "        prettyPrint(\"starting stack:\", str(1000 * n))\n",
    "        prettyPrint(\"end stack:\", str(getEndStack(player)))\n",
    "        prettyPrint(\"win/loss:\", str(getEndStack(player) - (1000 * n)  ))\n",
    "        prettyPrint(\"WPH:\", str((getEndStack(player) - (1000 * n)) / (rn*10)))\n",
    "        plotWinnings(player)\n",
    "        # end\n",
    "        print('-------------------------------------------------------------')\n",
    "        \n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f45a61bb-8373-4bd1-8fd6-b85a124517bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "seeking player:\n",
      "Results against:              PokerShark2                   \n",
      "number of games:              100                           \n",
      "number of games won:          93                            93.0%                         \n",
      "number of games drew:         0                             0.0%                          \n",
      "number of games lost:         7                             7.0%                          \n",
      "number of rounds:             9826                          \n",
      "number of rounds won:         6239                          63.5%                         \n",
      "number of rounds drew:        5                             0.1%                          \n",
      "number of rounds lost:        3582                          36.5%                         \n",
      "starting stack:               100000                        \n",
      "end stack:                    136520.0                      \n",
      "win/loss:                     36520.0                       \n",
      "WPH:                          0.3716670059027071            \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n",
      "risk-neutral player:\n",
      "Results against:              PokerShark1                   \n",
      "number of games:              100                           \n",
      "number of games won:          7                             7.0%                          \n",
      "number of games drew:         0                             0.0%                          \n",
      "number of games lost:         93                            93.0%                         \n",
      "number of rounds:             9826                          \n",
      "number of rounds won:         3582                          36.5%                         \n",
      "number of rounds drew:        5                             0.1%                          \n",
      "number of rounds lost:        6239                          63.5%                         \n",
      "starting stack:               100000                        \n",
      "end stack:                    63480.0                       \n",
      "win/loss:                     -36520.0                      \n",
      "WPH:                          -0.3716670059027071           \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "seeking = \"PokerShark1\"\n",
    "neutral = \"PokerShark2\"\n",
    "\n",
    "# print seeking stats\n",
    "print(\"seeking player:\")\n",
    "BotName = seeking\n",
    "os.rename(\"games\", neutral)\n",
    "Players = [neutral]\n",
    "PrintResult()\n",
    "\n",
    "# print Risk neutral stats\n",
    "print(\"risk-neutral player:\")\n",
    "BotName = neutral\n",
    "os.rename(neutral, seeking)\n",
    "Players = [seeking]\n",
    "PrintResult()\n",
    "os.rename(seeking, \"games\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecb3052c-f407-4cc7-a654-f4b4264b1b01",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
